/**
 * 搜索工具类
 * 提供搜索相关的工具函数
 */

// 搜索建议项接口
export interface SearchSuggestion {
	text : string
	type : '搜索历史' | '热门搜索' | '智能推荐'
	icon ?: string
}

// 搜索结果统计接口
export interface SearchResultStats {
	postCount : number
	circleCount : number
	userCount : number
	totalCount : number
}

// 搜索配置接口
export interface SearchConfig {
	maxHistoryCount : number
	maxSuggestionCount : number
	debounceDelay : number
	storageKey : string
}

// 默认搜索配置
const DEFAULT_CONFIG : SearchConfig = {
	maxHistoryCount: 10,
	maxSuggestionCount: 8,
	debounceDelay: 300,
	storageKey: 'searchHistory'
}

// 默认热门搜索关键词
const DEFAULT_HOT_KEYWORDS = [
	'科技', '生活', '美食', '旅行', '音乐',
	'电影', '读书', '健身', '摄影', '游戏'
]

/**
 * 搜索历史管理类
 */
export class SearchHistoryManager {
	private config : SearchConfig

	constructor(config : Partial<SearchConfig> = {}) {
		this.config = { ...DEFAULT_CONFIG, ...config }
	}

	/**
	 * 保存搜索历史
	 * @param keyword 搜索关键词
	 */
	saveHistory(keyword : string) : void {
		if (!keyword || !keyword.trim()) return

		try {
			const history = this.getHistory()
			// 移除重复项
			const newHistory = history.filter(item => item !== keyword.trim())
			// 添加到开头
			newHistory.unshift(keyword.trim())
			// 限制历史记录数量
			if (newHistory.length > this.config.maxHistoryCount) {
				newHistory.splice(this.config.maxHistoryCount)
			}
			// 保存到本地存储
			uni.setStorageSync(this.config.storageKey, newHistory)
		} catch (error) {
			console.error('保存搜索历史失败:', error)
		}
	}

	/**
	 * 获取搜索历史
	 * @returns 搜索历史数组
	 */
	getHistory() : string[] {
		try {
			const history = uni.getStorageSync(this.config.storageKey)
			return Array.isArray(history) ? history : []
		} catch (error) {
			console.error('获取搜索历史失败:', error)
			return []
		}
	}

	/**
	 * 清空搜索历史
	 */
	clearHistory() : void {
		try {
			uni.removeStorageSync(this.config.storageKey)
		} catch (error) {
			console.error('清空搜索历史失败:', error)
		}
	}

	/**
	 * 删除指定的搜索历史项
	 * @param keyword 要删除的关键词
	 */
	removeHistoryItem(keyword : string) : void {
		try {
			const history = this.getHistory()
			const newHistory = history.filter(item => item !== keyword)
			uni.setStorageSync(this.config.storageKey, newHistory)
		} catch (error) {
			console.error('删除搜索历史项失败:', error)
		}
	}
}

/**
 * 搜索建议生成器
 */
export class SearchSuggestionGenerator {
	private historyManager : SearchHistoryManager
	private hotKeywords : string[]
	private config : SearchConfig

	constructor(config : Partial<SearchConfig> = {}, hotKeywords : string[] = DEFAULT_HOT_KEYWORDS) {
		this.config = { ...DEFAULT_CONFIG, ...config }
		this.historyManager = new SearchHistoryManager(config)
		this.hotKeywords = hotKeywords
	}

	/**
	 * 生成搜索建议
	 * @param keyword 输入的关键词
	 * @returns 搜索建议数组
	 */
	generateSuggestions(keyword : string) : SearchSuggestion[] {
		if (!keyword || !keyword.trim()) return []

		const suggestions : SearchSuggestion[] = []
		const trimmedKeyword = keyword.trim().toLowerCase()

		// 从搜索历史中匹配
		const history = this.historyManager.getHistory()
		history.forEach(item => {
			if (item.toLowerCase().includes(trimmedKeyword) && item.toLowerCase() !== trimmedKeyword) {
				suggestions.push({
					text: item,
					type: '搜索历史',
					icon: 'clock'
				})
			}
		})

		// 从热门搜索中匹配
		this.hotKeywords.forEach(item => {
			if (item.toLowerCase().includes(trimmedKeyword) && item.toLowerCase() !== trimmedKeyword) {
				suggestions.push({
					text: item,
					type: '热门搜索',
					icon: 'fire'
				})
			}
		})

		// 生成智能推荐（基于关键词的相关推荐）
		const smartSuggestions = this.generateSmartSuggestions(trimmedKeyword)
		suggestions.push(...smartSuggestions)

		// 去重并限制数量
		const uniqueSuggestions = this.removeDuplicateSuggestions(suggestions)
		return uniqueSuggestions.slice(0, this.config.maxSuggestionCount)
	}

	/**
	 * 生成智能推荐
	 * @param keyword 关键词
	 * @returns 智能推荐数组
	 */
	private generateSmartSuggestions(keyword : string) : SearchSuggestion[] {
		const smartSuggestions : SearchSuggestion[] = []

		// 基于关键词的相关推荐逻辑
		const relatedKeywords = this.getRelatedKeywords(keyword)
		relatedKeywords.forEach(related => {
			smartSuggestions.push({
				text: related,
				type: '智能推荐',
				icon: 'bulb'
			})
		})

		return smartSuggestions
	}

	/**
	 * 获取相关关键词
	 * @param keyword 输入关键词
	 * @returns 相关关键词数组
	 */
	private getRelatedKeywords(keyword : string) : string[] {
		// 这里可以实现更复杂的相关词推荐逻辑
		// 目前提供一个简单的实现
		const relatedMap : Record<string, string[]> = {
			'科技': ['人工智能', '区块链', '5G', '物联网'],
			'美食': ['川菜', '粤菜', '烘焙', '甜品'],
			'旅行': ['自驾游', '背包客', '民宿', '攻略'],
			'音乐': ['流行', '古典', '摇滚', '民谣'],
			'电影': ['悬疑', '科幻', '爱情', '动作'],
			'读书': ['小说', '散文', '诗歌', '传记'],
			'健身': ['瑜伽', '跑步', '游泳', '力量训练'],
			'摄影': ['人像', '风景', '街拍', '微距'],
			'游戏': ['手游', '端游', '独立游戏', '电竞']
		}

		for (const [key, values] of Object.entries(relatedMap)) {
			if (keyword.includes(key)) {
				return values
			}
		}

		return []
	}

	/**
	 * 去除重复的搜索建议
	 * @param suggestions 搜索建议数组
	 * @returns 去重后的搜索建议数组
	 */
	private removeDuplicateSuggestions(suggestions : SearchSuggestion[]) : SearchSuggestion[] {
		const seen = new Set<string>()
		return suggestions.filter(suggestion => {
			if (seen.has(suggestion.text.toLowerCase())) {
				return false
			}
			seen.add(suggestion.text.toLowerCase())
			return true
		})
	}
}

/**
 * 防抖搜索类
 */
export class DebounceSearch {
	private timer : number | null = null
	private delay : number

	constructor(delay : number = 300) {
		this.delay = delay
	}

	/**
	 * 执行防抖搜索
	 * @param callback 搜索回调函数
	 * @param keyword 搜索关键词
	 */
	search(callback : (keyword : string) => void, keyword : string) : void {
		if (this.timer) {
			clearTimeout(this.timer)
		}

		this.timer = setTimeout(() => {
			callback(keyword)
			this.timer = null
		}, this.delay)
	}

	/**
	 * 取消防抖搜索
	 */
	cancel() : void {
		if (this.timer) {
			clearTimeout(this.timer)
			this.timer = null
		}
	}
}

/**
 * 搜索结果处理器
 */
export class SearchResultProcessor {
	/**
	 * 计算搜索结果统计
	 * @param postResults 帖子结果
	 * @param circleResults 圈子结果
	 * @param userResults 用户结果
	 * @returns 搜索结果统计
	 */
	static calculateStats(
		postResults : any[] = [],
		circleResults : any[] = [],
		userResults : any[] = []
	) : SearchResultStats {
		return {
			postCount: postResults.length,
			circleCount: circleResults.length,
			userCount: userResults.length,
			totalCount: postResults.length + circleResults.length + userResults.length
		}
	}

	/**
	 * 处理搜索响应
	 * @param response API响应
	 * @returns 处理后的结果数组
	 */
	static processSearchResponse(response : any) : any[] {
		if (!response || response.code !== 200) {
			return []
		}

		const data = response.data
		if (!data) {
			return []
		}

		// 如果是数组直接返回，如果是单个对象包装成数组
		return Array.isArray(data) ? data : [data]
	}

	/**
	 * 高亮搜索关键词
	 * @param text 原始文本
	 * @param keyword 搜索关键词
	 * @param highlightClass 高亮样式类名
	 * @returns 高亮后的HTML字符串
	 */
	static highlightKeyword(
		text : string,
		keyword : string,
		highlightClass : string = 'search-highlight'
	) : string {
		if (!text || !keyword) return text

		const regex = new RegExp(`(${keyword})`, 'gi')
		return text.replace(regex, `<span class="${highlightClass}">$1</span>`)
	}

	/**
	 * 截取搜索结果摘要
	 * @param content 完整内容
	 * @param keyword 搜索关键词
	 * @param maxLength 最大长度
	 * @returns 截取后的摘要
	 */
	static extractSummary(
		content : string,
		keyword : string,
		maxLength : number = 100
	) : string {
		if (!content) return ''

		const keywordIndex = content.toLowerCase().indexOf(keyword.toLowerCase())

		if (keywordIndex === -1) {
			// 如果没有找到关键词，返回开头部分
			return content.length > maxLength
				? content.substring(0, maxLength) + '...'
				: content
		}

		// 以关键词为中心截取
		const start = Math.max(0, keywordIndex - Math.floor(maxLength / 2))
		const end = Math.min(content.length, start + maxLength)

		let summary = content.substring(start, end)

		if (start > 0) summary = '...' + summary
		if (end < content.length) summary = summary + '...'

		return summary
	}
}

/**
 * 搜索工具主类
 */
export class SearchUtils {
	private historyManager : SearchHistoryManager
	private suggestionGenerator : SearchSuggestionGenerator
	private debounceSearch : DebounceSearch

	constructor(config : Partial<SearchConfig> = {}) {
		this.historyManager = new SearchHistoryManager(config)
		this.suggestionGenerator = new SearchSuggestionGenerator(config)
		this.debounceSearch = new DebounceSearch(config.debounceDelay)
	}

	/**
	 * 获取历史管理器
	 */
	get history() {
		return this.historyManager
	}

	/**
	 * 获取建议生成器
	 */
	get suggestions() {
		return this.suggestionGenerator
	}

	/**
	 * 获取防抖搜索器
	 */
	get debounce() {
		return this.debounceSearch
	}

	/**
	 * 获取结果处理器
	 */
	get processor() {
		return SearchResultProcessor
	}
}

// 导出默认实例
export const searchUtils = new SearchUtils()

// 导出工具函数
export const {
	saveHistory,
	getHistory,
	clearHistory,
	removeHistoryItem
} = searchUtils.history

export const {
	generateSuggestions
} = searchUtils.suggestions

export const {
	search: debounceSearch,
	cancel: cancelSearch
} = searchUtils.debounce

export const {
	calculateStats,
	processSearchResponse,
	highlightKeyword,
	extractSummary
} = SearchResultProcessor